#include <cstdlib>

/**
 * @brief 链表节点 
 */
typedef struct LinkedNode{
	// 存储数据  
	int data;
	// 下一个节点的地址 
	LinkedNode *next;	
}LinkedNode, *LinkedList;

/**
 * @brief 初始化一个不带头结点的单链表
 * 
 * @return LinkedList NULL
 */
LinkedList initLinkedListNoHead() {
	// 因为不带头结点，所以这个单链表的第一个元素就为NULL
	// 则直接返回NULL调用的时候使用声明并使用LinkedList接收即可 
	return nullptr;
}

/**
 * @brief 初始化一个带头结点的单链表
 * 
 * @return LinkedList 单链表的头节点
 */
LinkedList initLinkedListHaveHead() {
	// 为单链表申请一块内存空间，最为头节点
	LinkedList list = (LinkedNode *)malloc(sizeof(LinkedNode));
	// 初始化头节点之后无数据
	list -> next = nullptr;
	return list;
}

/**
 * @brief 没有头节点的单链表是否为空
 * 
 * @param l 一个没有头节点的单链表
 * @return true 为空
 * @return false 不为空
 */
bool isEmptyNoHead(LinkedList l) {
	// 因为没有头节点，直接判断其next是否为NULL
	return l == nullptr;
}

/**
 * @brief 有头节点的单链表是否为空
 * 
 * @param l 有头节点的单链表
 * @return true 为空
 * @return false 不为空
 */
bool isEmptyHaveHead(LinkedList l) {
	// 有头节点判断头节点的next是否为NULL
	return l -> next == nullptr;
}

/**
 * @brief 遍历打印无头结点单链表
 * 
 * @param list 无头结点单链表
 */
void noHeadPrint(LinkedList list) {
	LinkedNode *node = list;
	int i = 0;
	while (node != nullptr) {
		cout << "data" << i << "：" << node -> data << "\n" << endl;
		node = node -> next;
		i++;
	}
	
}

/**
 * @brief 遍历打印带头结点单链表
 * 
 * @param list 有头结点单链表
 */
void haveHeadPrint(LinkedList list) {
	LinkedNode *node = list -> next;
	int i = 0;
	while (node != nullptr) {
		cout << "data" << i << "：" << node -> data << "\n" << endl;
		node = node -> next;
		i++;
	}
	
}

/**
 * @brief 没有头节点的单链表在第一个位置插入
 * 
 * @param list 无头结点的单链表
 * @param data 要插入的数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool noHeadInsertToFirst(LinkedList &list, int data) {
	// 申请一个空间存放节点
	LinkedNode *node = (LinkedNode *)malloc(sizeof(LinkedNode));
	// 节点的数据赋值
	node -> data = data;
	// 将新节点的next指针指向链表指向的位置
	node -> next = list;
	// 更改链表指针
	list = node;
	return true;
}

/**
 * @brief 有头节点的单链表在第一个位置插入
 * 
 * @param list 有头节点的单链表
 * @param data 要插入的数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool haveHeadInsertToFirst(LinkedList &list, int data) {
	// 如果链表为空不进行插入
	if(list == nullptr) {
		return false;
	}
	// 为新节点申请内存空间
	LinkedNode *node = (LinkedNode *)malloc(sizeof(LinkedNode));
	// 新节点数据赋值
	node -> data = data;
	// 新节点的next指针指向头节点的next
	node -> next = list-> next;
	// 头节点的next指向新节点
	// 上面一部和这一步顺序不能调换不然将会丢失头节点之后的所有数据
	list -> next = node;
	return true;
}

/**
 * @brief 无头结点的单链表按位查找
 * 
 * @param list 
 * @param index 
 * @return LinkedNode* 
 */
LinkedNode* noHeadGetByIndex(LinkedList &list, int index) {
	// 如果当前链表为空直接返回NULL
	if (isEmptyNoHead(list)) {
		return nullptr;
	}
	
	// 下标不合法
	if (index < 0) {
		return nullptr;
	}
	

	// 声明临时节点指针指向链表的第一个节点
	LinkedNode *node = list;
	int i = 0;
	// 得到对应位置的节点
	while(node != nullptr && i < index) {
		node = node -> next;
		i++;
	}
	
	// 结束循环时i的值小于index的值
	// 证明index的值超过了最大下标返回NULL
	if(i < index) {
		return nullptr;
	}
	
	return node;
}

/**
 * @brief 有头节点按位查找
 * 
 * @param list 有头节点的单链表
 * @param index 要查找的下标（0开始）
 * @return LinkedNode* 节点指针
 */
LinkedNode* haveHeadGetByIndex(LinkedList &list, int index) {
	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return nullptr;
	}

	// 下标不合法
	if (index < 0) {
		return nullptr;
	}
	
	// 声明临时节点指针指向点链表的第一个元素下标为0
	LinkedNode *node = list -> next;
	int i = 0;
	// 得到对应位置的节点
	while(node != nullptr && i < index) {
		node = node -> next;
		i++;
	}
	
	// 结束循环时i的值小于index的值
	// 证明index的值超过了最大下标返回NULL
	if(i < index) {
		return nullptr;
	}
	
	return node;
}

/**
 * @brief 节点后插入新节点
 * 
 * @param node 执行后插的节点
 * @param data 插入的数据
 * @return true 让如成功
 * @return false 插入失败
 */
bool insertByNodeAfter(LinkedNode *node, int data) {
	// 节点为NULL无法操作
	if (node == nullptr) {
		return false;
	}
	
	// 为新节点申请内存空间
	LinkedNode *newNode = (LinkedNode *)malloc(sizeof(LinkedNode));

	// 新节点数据赋值
	newNode -> data = data;
	// 新节点的下一个元素为后插节点的下一个元素
	newNode -> next = node -> next;
	// 后插节点的下一个元素为新节点
	node -> next = newNode;
	return true;
}

/**
 * @brief 节点前插入数据
 * 
 * 因为单链表只能向一个方向查找，所以前插操作可以将前插操作的节点数据更新为要插入的数据，然后在将前插节点的原本的数据进行后插
 * 
 * @param node 前插节点
 * @param data 插入数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool insertByNodeFront(LinkedNode *node, int data) {
	// 节点指针为NULL无法操作
	if (node == nullptr) {
		return false;
	}

	// 将前插节点的数据进行保存
	int nodeData = node -> data;
	// 将前插节点的数据更新为要插入的数据
	node -> data = data;
	// 将前插节点的数据以后插方式插入到链表中
	return insertByNodeAfter(node, nodeData);
}

/**
 * @brief 无头结点单链表根据下标插入
 * 
 * @param list 无头节点的单链表
 * @param index 要插入的下标位置
 * @param data 要插入的位置
 * @return true 插入成功
 * @return false 插入失败
 */
bool noHeadInsterByIndex(LinkedList &list, int index, int data) {
	// 下标小于零为非法参数
	if (index < 0) {
		return false;
	}
	
	// 下标等于一直接调用没有头节点的单链表在第一个位置插入的方法
	if (index == 0) {
		noHeadInsertToFirst(list, data);
		return true;
	}
	
	// 链表为空无法操作
	if (isEmptyNoHead(list)) {
		return false;
	}

	// 调用不带头结点的单链表的按位查找找到要插入下标位置的前一个节点
	LinkedNode *node = noHeadGetByIndex(list, index - 1);

	// 如果返回的节点指针为NULL则证明下标不合法
	if (node == nullptr) {
		return false;
	}

	// 直接调用后插方法
	return insertByNodeAfter(node, data);
}

/**
 * @brief 带头结点的按位插入
 * 
 * @param list 带头结点的单链表
 * @param index 插入位置的下标
 * @param data 插入的数据
 * @return true 插入成功
 * @return false 插入失败
 */
bool haveHeadInsertByIndex(LinkedList &list, int index, int data) {
	// 下标小于零为非法参数
	if (index < 0) {
		return false;
	}
	
	// 下标等于零直接调用带头节点的单链表的在第一个位置插入的方法
	if (index == 0) {
		haveHeadInsertToFirst(list, data);
		return true;
	}

	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return false;
	}

	// 调用有头节点的按位查找获取插入下标的前一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	
	// 如果返回的节点指针为NULL则证明下标不合法
	if (node == nullptr) {
		return false;
	}
	
	// 直接调用后插方法
	return insertByNodeAfter(node, data);
}

/**
 * @brief 删除不带头结点的第一个元素
 * 
 * @param list 不带头结点的单链表
 * @return true 删除成功
 * @return false 删除失败
 */
bool noHeadRemoveFirst(LinkedList &list) {
	// 判断单链表是否为空
	bool flag = isEmptyNoHead(list);
	if (flag) {
		// 为空无法操作
		return false;
	}
	
	// 将无头节点的第一个元素进行临时保存
	LinkedNode *node = list;
	// 将无头节点的头指针指向第二个元素作为删除后的第一个元素
	list = node -> next;
	// 释放临时存储的第一个节点
	free(node);
	// 删除成功
	return true;
}

/**
 * @brief 带头结点删除第一个元素
 * 
 * @param list 到头节点的单链表
 * @return true 删除成功
 * @return false 删除失败
 */
bool haveHeadRemoveFirst(LinkedList &list) {
	// 判断带头结点的单链表是否为空
	bool flag = isEmptyHaveHead(list);
	if (flag) {
		// 为空无法操作
		return false;
	}

	// 将带头结点的额第一个元素及逆行临时保存
	LinkedNode *node = list -> next;
	// 将头节点的next域指向第二个节点
	list -> next = node -> next;
	// 释放第一个节点
	free(node);
	// 删除成功
	return true;
}

/** 1 2 3 4 5 6 7 8 9 10 i - n + 1
 * 	i = 10 n = 3
 *
 * @brief 无头节点根据下标删除
 * 
 * @param list 无头结点单链表
 * @param index 下标
 * @return true 删除成功
 * @return false 删除失败
 */
bool noHeadRemoveByIndex(LinkedList &list, int index) {
	// 链表为空无法操作
	if (isEmptyNoHead(list)) {
		return false;
	}

	// 获取要删除节点的前一个节点
	LinkedNode *node = noHeadGetByIndex(list, index - 1);
	if (node == nullptr) {
		// 如果前一个节点为NULL无法操作
		return false;
	}
	
	// 得到要删除的节点
	LinkedNode *removeNode = node -> next;
	// 将前一个节点的next指向删除的节点的下一个节点
	node -> next = removeNode -> next;
	// 释放删除的节点内存
	free(removeNode);
	// 删除成功
	return true;
}

/**
 * @brief 有头节点根据下标删除
 * 
 * @param list 有头节点单链表
 * @param index 下标
 * @return true 删除成功
 * @return false 删除失败
 */
bool haveHeadRemoveByIndex(LinkedList &list, int index) {
	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return false;
	}
	
	// 获取删除节点的上一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	// 上一个节点为空无法操作
	if (node == nullptr) {
		return false;
	}

	// 获取删除节点
	LinkedNode *removeNode = node -> next;
	// 将前一节点的next指向删除节点的next
	node -> next = removeNode -> next;
	// 释放删除节点的内存
	free(removeNode);
	// 删除成功
	return true;
}

/**
 * @brief 没有头节点的按值获取
 * 
 * @param list 不带头结点的单链表
 * @param data 要查找的数据
 * @return LinkedNode* 根据条件查找到的节点
 */
LinkedNode* noHeadGetByValueFirst(LinkedList &list, int data) {
	// 临时指针指向第一个节点
	LinkedNode *node = list;
	while (node != nullptr) {
		// 循环如果没到最后一个几点，判断当前节点的数据是否和传入数据相等
		if (node -> data == data) {
			// 相等返回这个节点
			return node;
		}
		// 不相等继续往下一个节点判断
		node = node -> next;
	}
	// 整个链表没找到对应的值返回NULL
	return nullptr;
}

/**
 * @brief 有头节点的按值获取
 * 
 * @param list 带头结点的单链表
 * @param data 要查找的数据
 * @return LinkedNode* 根据条件查找到的节点
 */
LinkedNode* haveHeadGetValueFirst(LinkedList &list, int data) {
	// 临时指针指向第一个节点
	LinkedNode *node = list -> next;
	while (node != nullptr) {
		// 循环如果没到最后一个几点，判断当前节点的数据是否和传入数据相等
		if (node -> data == data) {
			// 相等返回这个节点
			return node;
		}
		// 不相等继续往下一个节点判断
		node = node -> next;
	}
	// 整个链表没找到对应的值返回NULL
	return nullptr;
}

/**
 * @brief 无头节点的根据下标修改元素值
 * 
 * @param list 无头结点单链表
 * @param index 下标
 * @param data 目标数据
 * @return true 修改成功
 * @return false 修改失败
 */
bool noHeadModifyByIndex(LinkedList &list, int index, int data) {
	// 链表为空无法操作
	if (isEmptyNoHead(list)) {
		return false;
	}
	// 非法参数
	if (index < 0) {
		return false;
	}
	// 获取要修改位置节点的前一个节点
	LinkedNode *node = noHeadGetByIndex(list, index - 1);
	// 节点为NULL下标为非法参数
	if (node == nullptr) {
		return false;
	}
	// 将修改位置的数据赋值为新的值
	node -> next -> data = data;
	// 修改成功
	return true;
}

/**
 * @brief 有头节点的根据下标修改元素值
 * 
 * @param list 有头结点单链表
 * @param index 下标
 * @param data 目标数据
 * @return true 修改成功
 * @return false 修改失败
 */
bool haveHeadModifyByIndex(LinkedList &list, int index, int data) {
	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return false;
	}
	// 非法参数
	if (index < 0) {
		return false;
	}
	// 获取要修改位置节点的前一个节点
	LinkedNode *node = haveHeadGetByIndex(list, index - 1);
	// 节点为NULL下标为非法参数
	if (node == nullptr) {
		return false;
	}
	// 将修改位置的数据赋值为新的值
	node -> next -> data = data;
	// 修改成功
	return true;
}

/**
 * @brief 无头结点将链表中的某个值全部修改成另一个值
 * 
 * @param list 无头结点单链表
 * @param source 原值
 * @param target 目标值
 * @return true 修改成功
 * @return false 修改失败
 */
bool noHeadModifyByValue(LinkedList &list, int source, int target) {
	// 链表为空无法操作
	if (isEmptyNoHead(list)) {
		return false;
	}

	// 临时变量指向链表的第一个元素
	LinkedNode *node = list;
	while (node != nullptr) {
		if (node -> data == source) {
			// 如果当前节点的数据和传入的source相同，则修改成target
			node -> data = target;
		}
		node = node -> next;
	}
	// 修改成功
	return true;
}

/**
 * @brief 有头结点将链表中的某个值全部修改成另一个值
 * 
 * @param list 有头结点单链表
 * @param source 原值
 * @param target 目标值
 * @return true 修改成功
 * @return false 修改失败
 */
bool haveHeadModifyByValue(LinkedList &list, int source, int target) {
	// 链表为空无法操作
	if (isEmptyHaveHead(list)) {
		return false;
	}

	// 临时变量指向链表的第一个元素
	LinkedNode *node = list -> next;
	while (node != nullptr) {
		if (node -> data == source) {
			// 如果当前节点的数据和传入的source相同，则修改成target
			node -> data = target;
		}
		node = node -> next;
	}
	// 修改成功
	return true;
}

/**
 * @brief 无头节点的尾插法
 * 
 * @param dataArr 要插入的数据数组
 * @param initLength 初始化长度
 * @return LinkedList 初始化好的无头结点的单链表
 */
LinkedList noHeadCreateByTail(int dataArr[], int initLength) {
	// 初始化一个空的不带头结点的单链表
	LinkedList list = initLinkedListNoHead();
	// 声明一个节点指针指向链表
	LinkedNode *node = list;
	// 声明一个尾指针指向链表
	LinkedNode *tail = list;
	for (int i = 0; i < initLength; i++) {
		// 申请一个内存空间给节点指针
		node = (LinkedNode*) malloc(sizeof(LinkedNode));

		// 节点数据
		node -> data = dataArr[i];
		// 节点的next为空
		node -> next = nullptr;
		if (i == 0)	{
			// 如果当前是第一个元素则将头指针指向当前节点
			list = node;
		} else {
			// 如果不是第一个则将尾指针指向的节点的next指向新节点
			tail -> next = node;
		}
		// 将尾指针指向当前节点
		tail = node;
	}
	// 返回这个单链表
	return list;
}

/**
 * @brief 带头结点的尾插法
 * 
 * @param dataArr 初始数据数组
 * @param initLength 初始化长度
 * @return LinkedList 初始化完成的带头结点的单链表
 */
LinkedList haveHeadCreateByTail(int dataArr[], int initLength) {
	// 初始化一个带头结点的单链表
	LinkedList list = initLinkedListHaveHead();
	// 新节点指针
	LinkedNode *node = list;
	// 表尾指针
	LinkedNode *tail = list;
	for (int i = 0; i < initLength; i++) {
		// 新节点申请内存空间
		node = (LinkedNode*)malloc(sizeof(LinkedNode));
		// 新节点数据
		node -> data = dataArr[i];
		// 新节点的next指向NULL
		node -> next = nullptr;
		// 表尾指针的next指向新节点
		tail -> next = node;
		// 将尾指针指向当前节点
		tail = node;
	}
	// 返回这个单链表
	return list;
}

/**
 * @brief 无头结点的头插法
 * 
 * @param dataArr 初始化数据
 * @param initLehgth 初始化长度
 * @return LinkedList 初始化完成的无头结点单链表
 */
LinkedList noHeadCreateByHead(int dataArr[], int initLength) {
	// 初始化一个无头结点的的单链表
	LinkedList list = initLinkedListNoHead();
	for (int i = 0; i < initLength; i++) {
		// 为新节点申请内存空间
		LinkedNode *node = (LinkedNode*)malloc(sizeof(LinkedNode));
		// 新节点数据赋值
		node -> data = dataArr[i];
		if(i == 0) {
			// 头插法数组第一个元素最终为表尾元素
			node -> next = nullptr;
		} else {
			// 其他元素的next指向当list的第一个元素
			node -> next = list;
		}
		// list指向当前节点
		list = node;
	}
	// 返回这个链表
	return list;
}

/**
 * @brief 有头节点的头插法
 * 
 * @param dataArr 初始数据
 * @param initLength 初始化长度
 * @return LinkedList 初始化完成的有头节点的单链表
 */
LinkedList haveHeadCreateByHead(int dataArr[], int initLength) {
	// 初始化一个空的带头结点的单链表
	LinkedList list = initLinkedListHaveHead();
	for (int i = 0; i < initLength; i++) {
		// 为新节点申请内存kong'jian
		LinkedNode *node = (LinkedNode*)malloc(sizeof(LinkedNode));
		// 新节点数据赋值
		node -> data = dataArr[i];
		if (i == 0) {
			// 头插法第一个元素为初始化完最终的表尾元素，所以next为NULL
			node -> next = nullptr;
		} else {
			// 出第一个元素外其他元素next指向头节点的next
			node -> next = list -> next;
		}
		// 头节点指向新节点
		list -> next = node;
	}
	// 返回这个带头节点的单链表
	return list;
}

/**
 * @brief 无头结点单链表逆置
 * 
 * @param list 无头结点单链表
 * @return LinkedList 逆置后的单链表
 */
LinkedList noHeadInversion(LinkedList list) {
	// 定义指针指向存储原单链表的数据
	int *data;
	// 临时指针指向单链表的每个节点
	LinkedNode *node = list;
	LinkedNode *temp;
	// 计数器
	int i = 0;
	while (node != nullptr) {
		// 循环单链表的节点存储数据
		data[i] = node -> data;
		temp = node -> next;
		// 释放节点内存空间
		free(node);
		// 指向下一个节点
		node = temp;
		i++;
	}
	// 头插法逆置返回逆置后的单链表
	return noHeadCreateByHead(data, i);
}

/**
 * @brief 有头结点单链表逆置
 * 
 * @param list 有头结点单链表
 * @return LinkedList 逆置后的单链表
 */
LinkedList haveHeadInversion(LinkedList list) {
	// 定义指针指向存储原单链表的数据
	int *data;
	// 临时指针指向单链表的每个节点
	LinkedNode *node = list -> next;
	LinkedNode *temp;
	// 计数器
	int i = 0;
	while (node != nullptr) {
		// 循环单链表的节点存储数据
		data[i] = node -> data;
		temp = node -> next;
		// 释放节点内存空间
		free(node);
		// 指向下一个节点
		node = temp;
		i++;
	}
	// 头插法逆置返回逆置后的单链表
	return haveHeadCreateByHead(data, i);
}








